#include <iostream>
using namespace std;

//偏特化1
template<typename T>
class A {
public:
	void print() {
		cout << "A<T>" << endl;
	}
};

//偏特化2
template<typename T>
class A<T*> {
public:
	void print() {
		cout << "A<T*>" << endl;
	}
};

//偏特化3
template<typename T>
class A<T* const> {
public:
	void print() {
		cout << "A<T* const>" << endl;
	}
};

//偏特化4
template<typename T>
class A<T* volatile> {
public:
	void print() {
		cout << "A<T* volatile>" << endl;
	}
};

//偏特化5
template<typename T>
class A<T* const volatile> {
public:
	void print() {
		cout << "A<T* const volatile>" << endl;
	}
};
//全特化
template<>
class A<int> {
public:
	void print() {
		cout << "A<int>" << endl;
	}
};

//测试 
// 注意：友元函数不能偏特化，只能全特化。
class alloc {  };
//函数模板只占用一个编译单元，其中定义的Alloc和BufSiz都不会被实例化，因此不占用额外的空间。
template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque {
public:
	deque() { cout << "deque" << endl; }
};

template <class T, class Sequence>
class stack;

template <class T, class Sequence>
bool operator == (const stack<T, Sequence>& x,
	const stack<T, Sequence>& y);

template <class T, class Sequence>
bool operator <  (const stack<T, Sequence>& x,
	const stack<T, Sequence>& y);

template <class T, class Sequence = deque<T> >
class stack {
	// 这种写法是OK的
	friend bool operator== <T> (const stack<T>&, const stack<T>&);
	friend bool operator< 	<T> (const stack<T>&, const stack<T>&);

	friend bool operator== <T> (const stack&, const stack&);
	// 这种写法也是OK的
	friend bool operator< 	<T> (const stack&, const stack&);

	// 这种写法也是OK的		 
	friend bool operator== <> (const stack&, const stack&);
	friend bool operator<  <> (const stack&, const stack&);

	// 这种写法是错误的 
	// friend bool operator== ( const stack&, const stack& );
	// friend bool operator<  ( const stack&, const stack& );

public:
	stack() { cout << "stack" << endl; }
private:
	Sequence c;
};

template <class T, class Sequence>
bool operator== (const stack<T, Sequence>& x,
	const stack<T, Sequence>& y) {
	 cout << "operator==" << '\t';
	 return true;
}

template <class T, class Sequence>
bool operator<  (const stack<T, Sequence>& x,
	const stack<T, Sequence>& y) {
	 cout << "operator<" << '\t';
	 return true;
}

 //  Defines __STL_CONFIG_H if the compiler is a conforming C++ compiler.
/*		 如果编译器是一个符合C++标准的编译器，就定义__STL_CONFIG_H
*/
//作用：告诉编译器，当前编译的STL是符合C++标准的。
template <class T, class Alloc = alloc>
class vector {
public:
	typedef T value_type;
	typedef value_type* iterator;

	template <class I>
	// 注意：这里的I是迭代器类型，而不是指针类型
	void insert( iterator position, I first, I last ) {
		cout << "insert()" << endl;
	}
};
 namespace mydeque{
 class alloc { };
inline size_t __deque_buf_size( size_t n, size_t sz )
{
	return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
}
//__deque_iterator是一个模板结构，用于定义双端队列（deque）的迭代器。
//有两个模板参数：T（元素类型）、Ref（引用类型）、Ptr（指针类型）和BufSiz（缓冲区大小）。
//buffer_size是一个静态函数，返回每个缓冲区的大小。这个大小计算方式是：如果BufSiz非零，则返回BufSiz；否则，返回512除以元素大小（sizeof(T)）的结果，但至少为1。
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
	typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
	typedef __deque_iterator<T, const T& ,const T*, BufSiz> const_iterator;
	static size_t buffer_size() { return __deque_buf_size( BufSiz, sizeof(T) ); }
};
 

template <class T, class Alloc = alloc, size_t BufSiz = 0>
class deque {
public:
	typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
};
}
int main() {
	//偏特化是模板的一种特殊化，它只对部分类型进行特化，其他类型仍然使用模板的默认实现。
	//在模板类中，偏特化可以让模板的行为更加灵活，可以根据不同的类型选择不同的实现。
	//作用：减少代码重复，提高效率
	//偏特化的语法格式如下：
	//template<class T> class A{...};
	//template<class T, class U> class A<T*>{...};
	//template<class T, class U> class A<T* const>{...};
	//template<class T, class U> class A<T* volatile>{...};
	//template<class T, class U> class A<T* const volatile>{...};
	//template<> class A<int>{...};
	//以上代码定义了五个偏特化模板类A，分别对int、int*、int* const、int* volatile、int* const volatile和全特化int类型进行了特化。
	//下面实例化这些模板类，并调用其print()函数，输出不同的类型信息。、
	//$$注意偏特化的顺序，特化的顺序不影响结果。函数模板不能偏特化，只能全特化。
	A<int> a;
	a.print();
	A<int*> b;
	b.print();
	A<int* const> c;
	c.print();
	A<int* volatile> d;
	d.print();
	A<int* const volatile> e;
	e.print();
	//全特化
	//全特化是指对所有类型进行特化，也就是说，不管使用什么类型，都使用同一个模板实现。
	//全特化的语法格式如下：
	//template<> class A<int>{...};
	//以上代码定义了一个全特化模板类A，对所有int类型都使用同一个模板实现。
	//下面实例化这个模板类，并调用其print()函数，输出int类型信息。
	A<int> f;
	f.print();
    //test
    deque<int > d1;
    cout<<sizeof(d1)<<endl;
	//test 
	stack<int> x;
	stack<int> y;

	cout << (x == y) << endl;		// operator == 	1
	cout << (x < y) << endl;		// operator< 	1

	stack<char> y1;
	//cout << (x == y1) << endl;	// error: no match for...
	//cout << (x <y1) << endl;		// error: no match for...
	//test vector
	int ia[] = { 0, 1, 2, 3, 4 };
	vector<int> V_x;
	vector<int>::iterator ite;
	//将ia数组中的元素插入到V_x中，从位置ite开始，共插入5个元素
	V_x.insert( ite, ia, ia + 5 );
	 
	cout << endl;
   cout <<mydeque:: deque<int, alloc, 128>::iterator::buffer_size() << endl; // 128
   cout <<mydeque:: deque<int, alloc, 64>::iterator::buffer_size() << endl; // 1
	
	return 0;
}
